package com.demo.java.OD401_450.OD421;

import java.util.*;

/**
 * @author bug菌
 * @Source 公众号：猿圈奇妙屋
 * @des： 【学生重新排队、小朋友分组最少调整次数(C&D卷-200分)】问题
 * @url： https://blog.csdn.net/weixin_43970743/article/details/146361685
 */
public class OdMain {

    // 当前排队的学生顺序
    public static List<Integer> cur_order = new ArrayList<>();
    // 最终应该的学生顺序
    public static List<Integer> final_order = new ArrayList<>();
    // 学生所属组的标志（用0表示没有操作过，1表示操作过）
    public static List<Integer> order_flags = new ArrayList<>();
    public static int n = 0;

    // 用map来存储每个学生与其所在组号的映射关系
    public static Map<Integer, Integer> relations = new HashMap<>();
    // 用来记录调整的次数
    public static int result = 0;

    // 判断当前学生顺序是否符合最终顺序
    public static boolean check_order() {
        for (int i = 0; i < cur_order.size(); i += 3) {
            // 每三个学生应该在同一组
            if (!(relations.get(cur_order.get(i)) == relations.get(cur_order.get(i + 1)) &&
                    relations.get(cur_order.get(i)) == relations.get(cur_order.get(i + 2)))) {
                return false;
            }
        }
        return true;
    }

    // 将当前学生移到新的位置
    public static void move(int cur_student, int remove_index, int append_index) {
        // 如果当前学生与要移动的学生属于同一组，则移动该学生
        if (relations.get(cur_order.get(remove_index)) == relations.get(cur_student)) {
            int remove_element = cur_order.get(remove_index);
            cur_order.remove(remove_index);
            cur_order.add(append_index, remove_element);
        }
    }

    // 执行两步调整的操作
    public static void two_step_move() {
        for (int i = 0; i < n; i++) {
            int cur_student = cur_order.get(i);
            if (order_flags.get(relations.get(cur_student)) == 0) {
                result += 2; // 表示该操作至少会调整两次
                for (int j = 0; j < n; j++) {
                    if (cur_order.get(j) != cur_student) {
                        move(cur_student, j, i); // 移动当前学生
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        // 读取输入的当前顺序
        String[] tmp1 = in.nextLine().split(" ");
        for (int i = 0; i < tmp1.length; i++) {
            cur_order.add(Integer.parseInt(tmp1[i]));
        }

        // 读取输入的最终顺序
        String[] tmp2 = in.nextLine().split(" ");
        for (int i = 0; i < tmp2.length; i++) {
            final_order.add(Integer.parseInt(tmp2[i]));
        }

        n = cur_order.size(); // 获取学生数量

        // 初始化order_flags，表示每个学生是否已经参与过调整操作
        for (int j = 0; j < n; j++) {
            order_flags.add(0);
        }

        // 将每个学生与其组号对应
        int k = 0;
        while (true) {
            if (k >= n) {
                break;
            } else {
                // 通过每三个学生将他们分为一组，给每个学生标记组号
                for (int j = 0; j < 3; j++) {
                    relations.put((final_order.get(k + j)), k / 3 + 1);
                }
            }
            k += 3;
        }

        // 开始调整，直到顺序符合要求
        while (!check_order()) {
            int operation_flag = 0;

            int i = 0;
            while (true) {
                if (i >= n) {
                    break;
                } else {
                    int cur_student = cur_order.get(i);
                    if (order_flags.get(relations.get(cur_student)) == 0) {
                        // 判断当前学生后面是否有同组的学生
                        Integer count = 0;
                        Integer cur_stu_order = relations.get(cur_student);

                        if (i + 1 < n && relations.get(cur_order.get(i + 1)) == cur_stu_order) {
                            order_flags.set(relations.get(cur_student), 1);
                            count += 1;
                            if (i + 2 < n && relations.get(cur_order.get(i + 2)) == cur_stu_order) {
                                count += 1;
                            }
                        }

                        // 如果当前学生有一个同组的学生，则需要操作1次
                        if (count == 1) {
                            order_flags.set(relations.get(cur_student), 1);
                            result += 1;
                            operation_flag = 1;
                            for (int j = 0; j < n; j++) {
                                if (j != i && j != i + 1) {
                                    move(cur_student, j, i); // 移动当前学生到指定位置
                                }
                            }
                        }
                        // 如果当前学生有两个同组的学生，则不需要操作
                        if (count == 2) {
                            order_flags.set(relations.get(cur_student), 1);
                        }
                    }
                }
                i += 1;
            }

            // 若每个学生后面的两个学生都没有同组的情况，则执行两步调整操作
            if (operation_flag == 0) {
                two_step_move();
            }
        }

        // 输出最终的操作次数
        System.out.println(result);
    }

    // 用来将输入的字符串按逗号分隔成整数数组
    public static int[] split(String input_str) {
        String[] tmp2 = input_str.split(",");
        int[] nums = new int[tmp2.length];
        for (int i = 0; i < tmp2.length; i++) {
            nums[i] = Integer.parseInt(tmp2[i]);
        }
        return nums;
    }
}
